package LinkedListPackage;

/**
 * @author Lzm
 * @version 1.0
 */
public class DLinkedList {
  public static void main(String[] args) {
    DoubleListNode n1 = new DoubleListNode(1,"11");
    DoubleListNode n2 = new DoubleListNode(2,"22");
    DoubleListNode n3 = new DoubleListNode(3,"33");

    /*添加节点*/
    DoubleLinkedList dl = new DoubleLinkedList();
    dl.add(n1);
    dl.add(n2);
    dl.add(n3);
    /*遍历链表*/
    dl.list();
    System.out.println("===============");
    System.out.println(n1.next);
    System.out.println(n2.pre);
    System.out.println(n1.pre);
    System.out.println(n3.next );

    /*修改节点*/
    DoubleListNode n4 = new DoubleListNode(3,"3333333");
    dl.update(n4);
    dl.list();
    System.out.println("===============");

    /*删除节点*/
    dl.delete(1);
    dl.list();
    System.out.println("===============");
    dl.delete(3);
    dl.list();
    System.out.println("===============");
  }
}
/*定义双链表的节点*/
class DoubleListNode{
  public int no;
  public String name;
  /*指向后一个节点*/
  public DoubleListNode next;

  /*指定前一个节点*/
  public DoubleListNode pre;
  public DoubleListNode(int no, String name){
    this.name = name;
    this.no = no;
  }

  public String toString() {
    return "LinkedListPackage.LinkedList.DoubleListNode{no = " + no + ", name = " + name + "}";
  }
}
/*定义双链表*/
class DoubleLinkedList{
  /*定义头节点*/
  private final DoubleListNode head = new DoubleListNode(0,"");

  /*返回头节点*/
  public DoubleListNode getHeadNode(){
    return this.head;
  }

  /*遍历双链表*/
  public void list(){
    /*1. 判断双链表是否为空*/
    if (head.next == null){
      System.out.println("链表为空");
      return ;
    }

    /*2. 定义临时辅助节点*/
    DoubleListNode temp = head.next;

    /*3. 链表不为空时, 用while循环遍历双链表*/
    while(true){
      /*4. 判断临时辅助节点是否遍历到最后*/
      if (temp== null){
        break;
      }
      /*5. 遍历节点*/
      System.out.println(temp);
      temp = temp.next;
    }
  }

  /*添加节点*/
  public void add(DoubleListNode node){
    /*1. 判断要添加的节点是否合法*/
    if (node == null){
      return;
    }
    /*2. 定义临时辅助节点*/
    DoubleListNode temp = head;

    /*3. 利用while来遍历到链表尾部来进行添加*/
    while(true){
      if (temp.next == null){
        break;
      }
      temp = temp.next;
    }
    /*4. 将节点添加到链表尾部*/
    temp.next = node;
    node.pre = temp;
  }

  /*修改节点*/
  /*修改单链表的节点值*/
  public void update(DoubleListNode node){
    /*1. 判断传进来的节点是否为空 或 单链表是否为空*/
    if (node == null || head.next == null){
      System.out.println("参数无效或链表为空");
      return;
    }
    /*定义临时辅助节点*/
    DoubleListNode temp = head.next;
    /*2. while循环找到要修改的节点*/
    while(true){
      /*如果临时辅助节点指向了单链表的最后一个节点, 说明没有修改的节点不在单链表中*/
      if (temp.next == null){
        System.out.println("无符合的节点");
        return ;
      }
      /*如果temp.next.no == node.no 说明找到了要修改的节点, 停止while*/
      if (temp.next.no == node.no){
        break;
      }
      temp = temp.next;
    }
    /*4. 找到了要修改的节点, 令temp.next.name = node.name*/
    temp.next.name = node.name;
  }

  /*删除节点*/
  public void delete(int no){
    /*1. 判断链表是否为空 或 传入参数是否不合法*/
    if (head.next == null || no <= 0 ){
      return;
    }
    /*2. 定义临时辅助节点*/
    DoubleListNode temp = head.next;

    /*3. 利用while循环找到要删除的节点*/
    while(true){
      /*4. 判断是否找到符合节点*/
      if (temp == null){
        /*4.1 不存在符合的节点, return*/
        System.out.println("无符合的节点");
        return;
      }

      /*4.2 找到符合节点*/
      if (temp.no == no){
        /*4.2.1 判断要删除的节点是否是最后一个节点*/
        if (temp.next == null){
          /*令temp的前一个结点的next 为 null*/
          temp.pre.next = null;
          return;
        }
        /*直接进行删除操作*/
        temp.pre.next = temp.next;
        temp.next.pre = temp.pre;
        return;
      }
      temp = temp.next;
    }
  }
}
